const person = {
    name: '张三',
    get aliasName() {
        return this.name + '123'
    }
}

const proxyPerson = new Proxy(person, {
    get(target, key, receiver) {

        // console.log('get', target, key, receiver);
        /**
         * 1. 当你访问 proxyPerson.aliasName 时，get 捕获器第一次被触发，key 是 'aliasName'。
         * 2. 在 aliasName 的 getter 中，this.name 被访问，this 指向 proxyPerson.
         *  所以 get 捕获器第二次被触发，key 是 'name'。
         * 
         * 输出结果：
         * aliasName
         * name
         * 张三123
         */
        console.log(key);

        /**
         * target: { name: '张三', aliasName: [Getter] }
         * key: aliasName
         * receiver: Proxy { name: '张三', aliasName: [Getter] }
         * 
         * 1. target: 这是被代理的目标对象，也就是你传入 Proxy 构造函数的第一个参数。在你的代码中，target 就是 person 对象。
         * 2. key: 这是你正在访问的属性名。例如，当你访问 proxyPerson.aliasName 时，key 就是 'aliasName'。
         * 3. receiver: 这是最初被调用的对象，通常是代理对象本身。在你的代码中，receiver 就是 proxyPerson。
         * 
         * 什么是最初被调用的对象？： 触发 get 的代理对象 就是最初被调用的对象.
         * proxyPerson是代理对象，访问它其中的aliasName，就会触发它的get方法，
         * 那么proxyPerson就是最初被调用的对象，receiver就是proxyPerson
         */

        // return target[key] // person.name  不会触发 get  person里面的name没有被代理
        // 所以此处使用 receiver[key],但是receiver是代理对象，又会触发get方法，
        // return receiver[key]
        // 所以需要使用Reflect.get(target, key, receiver)
        return Reflect.get(target, key, receiver)

        /**
         * Reflect.get(target, key, receiver) 是 Reflect 对象的一个方法，用于获取目标对象的属性值。
         * 
         * Reflect是一个特定的对象，它能像操作  普通对象  一样操作  代理对象。
         * 同时拿到 target 和 receiver 的值, 将target[key] 的值返回给 receiver[key]
         * Reflect.get(target, key, receiver) === receiver[key]
         */
    },

})

console.log(proxyPerson.aliasName);

//在使用 proxy 的时候 ， 要搭配 Reflect 使用

